/*
Copyright [2012] [Maria Eugenia Malagamba]
Copyright [2012] [Leandro Pellegrino]
Copyright [2012] [Julia Gambuzzi]
Copyright [2012] [Ignacio Capodanno]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

#include "PartidaCliente.h"

PartidaCliente::PartidaCliente(int numeroNave)
{
	this->cliente = NULL;
	this->tablero = NULL;
	this->numeroNave = numeroNave;
	this->escenario = "";
	this->resultadoPartida = JUGANDO;
	this->sonido = new Sonido();
	this->animaciones = new vector<Animacion*>;
}

void PartidaCliente::setResultadoPartida(estados_juego resultado){
	this->resultadoPartida = resultado;
}

estados_juego PartidaCliente::getResultadoPartida(){ 
	return this->resultadoPartida;
}

void PartidaCliente::setNombreCliente(string nombre){
	this->nombreCliente = nombre;
}

string PartidaCliente::getNombreCliente(){
	return this->nombreCliente;
}

int PartidaCliente::unirseAPartida(string puerto, string host){

	this->cliente = new Cliente(puerto, host);
	if (cliente->crearSocket() != -1){
		if (cliente->conectar() != -1){
			//todas las operaciones se realizaron correctamente
			return 0;
		}
	}

	return -1;
}

int PartidaCliente::recibirEscenario(string nombreJugador){

	this->setNombreCliente(nombreJugador);
	//Creo la carpeta que contiene los archivos recibidos.
	this->pathCarpetaCliente = ".\\ArchivosRecibidos - "+nombreJugador+"\\";
	CreateDirectoryA(this->pathCarpetaCliente.c_str(), NULL);

	this->escenario = this->pathCarpetaCliente+this->cliente->recibirString();

	//Recibir el XML
	this->cliente->recibirArchivo(this->pathCarpetaCliente);

	//Si es el servidor envia las imagenes del escenario
	int cantidadImagenes = this->cliente->recibirEntero();

	for (unsigned int i = 0; i < cantidadImagenes; i++){
		this->cliente->recibirArchivo(this->pathCarpetaCliente);
	}

	//envio el numero de la nave
	this->cliente->enviarEntero(this->numeroNave);
	this->numeroNave=this->cliente->recibirEntero();
	//envio nombre jugador
	this->cliente->enviarString(nombreJugador);

	return 0;

}

void PartidaCliente::iniciar(int naveOtroCliente,int numeroJugador, string nombreOtroCliente){


	//lanzar el hilo que recibe mensajes y actualiza el modelo

	if(numeroJugador == 1){
		this->tablero = new Tablero(this->escenario, this->pathCarpetaCliente, nombreOtroCliente, this->getNombreCliente(), true, naveOtroCliente,this->numeroNave); // TODO: this->numeroNaveOtroCliente??
	}else{
		this->tablero = new Tablero(this->escenario, this->pathCarpetaCliente, this->getNombreCliente(), nombreOtroCliente,  true, this->numeroNave, naveOtroCliente); // TODO: this->numeroNaveOtroCliente??   
	}

	if(numeroJugador == 1){
		this->jugadorPartida = this->tablero->getJugadorDos();
		this->jugadorContrario = this->tablero->getJugadorUno();
	}else{
		this->jugadorPartida = this->tablero->getJugadorUno();
		this->jugadorContrario  = this->tablero->getJugadorDos();
	}

	//Boton Salir
	Boton* botonSalir = new Boton(592,432,"Salir");
	Uint32 tiempoTranscurrido;

	//Toma el tiempo que tarda en responder SDL
	tiempoTranscurrido = SDL_GetTicks();

	//Lanza el hilo para recibir el estado del escenario.
	this->recibirEstadoEscenario();

	Teclado teclado;

	SDL_Event evento;
	bool terminar = false;


	while(terminar == false) {
		if (Mix_PlayingMusic() == 0)
		{
			this->sonido->reproducirAmbiente(this->sonido->getSoundAmbiente());
		}
		//Toma el tiempo que tarda en responder SDL
		tiempoTranscurrido = SDL_GetTicks();

		////Repintar la pantalla
		//Uint32 negro = SDL_MapRGB(tablero->getPantalla()->format,0,0,0);
		//SDL_FillRect(tablero->getPantalla(), NULL, negro);

		SDL_Rect rect;
        rect.x = 0;
        rect.y = 0;

        SDL_BlitSurface(this->tablero->getFondo(),NULL,this->tablero->getPantalla(),&rect);

		HANDLE hMutex = CreateMutex(NULL, FALSE, TEXT("datosMutex"));
		DWORD dwWaitResult = WaitForSingleObject(hMutex, INFINITE); 
		int estado;

		if (dwWaitResult == WAIT_OBJECT_0){

			//Se pintan los asteroides en la pantalla
			for(int i=0; i < this->tablero->getAsteroides()->size();i++){
				if(this->tablero->getAsteroides()->at(i)->getEstado()){
					this->sonido->reproducir(this->sonido->getSoundChoque());
					int alto = this->tablero->getAsteroides()->at(i)->getAltoDeLaImagen();
					int ancho = this->tablero->getAsteroides()->at(i)->getAnchoDeLaImagen();
					if (alto > ancho )
						ancho =alto;
					Animacion* animacion = new Animacion(this->tablero->getAsteroides()->at(i)->getPosicionX(),this->tablero->getAsteroides()->at(i)->getPosicionY(),
						"explosionNave.bmp",ancho*2,ancho*2,5);
					this->animaciones->push_back(animacion);
					this->tablero->getAsteroides()->at(i)->setEstado(false);
				}

				if (this->tablero->getAsteroides()->at(i)->getTamanioAsteroide() != 0){
					this->tablero->getAsteroides()->at(i)->pintarImagen(this->tablero->getPantalla());
				}
			}

			//Se pintan las armas del cliente 1 en la pantalla
			for(int i=0; i < this->tablero->getArmas()->size();i++){
				if (numeroJugador == 1){
					if (this->tablero->getArmas()->at(i)->getTipo() != 'I'){
						this->tablero->getArmas()->at(i)->pintarImagen(this->tablero->getPantalla());
					}
				} else {
					this->tablero->getArmas()->at(i)->pintarImagen(this->tablero->getPantalla());
				}

				if (this->tablero->getArmas()->at(i)->getTipo() == 'I' && this->tablero->getArmas()->at(i)->getEstado() == 'D'){
					sonido->reproducir(sonido->getSoundChoque());
					this->animacionesBonus(MINA,this->tablero->getArmas()->at(i));                                          
				}

			}

			//Se pintan las armas del cliente 2 en la pantalla
			for(int i=0; i < this->tablero->getArmasOtroCliente()->size();i++){
				if (numeroJugador == 0){
					if (this->tablero->getArmasOtroCliente()->at(i)->getTipo() != 'I'){
						this->tablero->getArmasOtroCliente()->at(i)->pintarImagen(this->tablero->getPantalla());
					}
				} else {
					this->tablero->getArmasOtroCliente()->at(i)->pintarImagen(this->tablero->getPantalla());
				}

				if (this->tablero->getArmasOtroCliente()->at(i)->getTipo() == 'I' && this->tablero->getArmasOtroCliente()->at(i)->getEstado() == 'D'){
					this->sonido->reproducir(sonido->getSoundChoque());
					this->animacionesBonus(MINA,this->tablero->getArmasOtroCliente()->at(i));
				}
			}

			//Se pintan los bonus en la pantalla
			for(int i=0; i < this->tablero->getBonus()->size();i++){
				if( this->tablero->getBonus()->at(i)->esNuevo()){
					sonido->reproducir(this->sonido->getSoundBonus());
					Animacion* animacion = new Animacion(this->tablero->getBonus()->at(i)->getPosicionX()- 37,this->tablero->getBonus()->at(i)->getPosicionY() - 30,"animacionBonus.bmp",50,50,10);
					this->animaciones->push_back(animacion);
					this->tablero->getBonus()->at(i)->setNuevo(false);
				}
				this->tablero->getBonus()->at(i)->pintarImagen(this->tablero->getPantalla());
			}

			pintarBase(this->jugadorPartida);
			pintarBase(jugadorContrario);

			//Se pinta la nave del 1er cliente en la pantalla
			if (!this->jugadorPartida->getNave()->getEnReparacion()){
				this->jugadorPartida->getNave()->pintarImagen(tablero->getPantalla());
				this->jugadorPartida->getNave()->volar();
				this->jugadorPartida->getNave()->getEnergia()->pintarImagen(tablero->getPantalla());

				if (this->jugadorPartida->getNave()->getEscudo() != NULL){ 
					this->jugadorPartida->getNave()->getEscudo()->pintarImagen(tablero->getPantalla());
					this->jugadorPartida->getNave()->getEscudo()->getEnergia()->pintarImagen(tablero->getPantalla());
				}
				if (this->jugadorPartida->getNave()->getSuperEscudo() != NULL) 
					this->jugadorPartida->getNave()->getSuperEscudo()->pintarImagen(tablero->getPantalla());
			}
			//Se pinta la nave del 2do cliente en la pantalla
			if (!this->jugadorContrario->getNave()->getEnReparacion() && !this->jugadorContrario->getNave()->esInvisible()){
				this->jugadorContrario->getNave()->pintarImagen(tablero->getPantalla());
				this->jugadorContrario->getNave()->volar();
				this->jugadorContrario->getNave()->getEnergia()->pintarImagen(tablero->getPantalla());

				if (this->jugadorContrario->getNave()->getEscudo() != NULL){ 
					this->jugadorContrario->getNave()->getEscudo()->pintarImagen(tablero->getPantalla());
					this->jugadorContrario->getNave()->getEscudo()->getEnergia()->pintarImagen(tablero->getPantalla());
				}
				if (this->jugadorContrario->getNave()->getSuperEscudo() != NULL) 
					this->jugadorContrario->getNave()->getSuperEscudo()->pintarImagen(tablero->getPantalla());
			}


			if(numeroJugador == 1)
				this->tablero->getJugadorDos()->pintarBonus(this->tablero->getPantalla());
			else
				this->tablero->getJugadorUno()->pintarBonus(this->tablero->getPantalla());

			for(int i=0; i < this->animaciones->size();i++){
				this->animaciones->at(i)->pintarImagen(this->tablero->getPantalla());
				this->animaciones->at(i)->siguienteFrame();
				if(this->animaciones->at(i)->getNumeroDeFrame() == this->animaciones->at(i)->getMaxNumeroDeFrame()-1){
					Animacion* animacionAEliminar =  this->animaciones->at(i);
					this->animaciones->erase(this->animaciones->begin()+i);
					delete animacionAEliminar;
				}
			}

			botonSalir->mostrar(tablero->getPantalla());

			SDL_Flip(this->tablero->getPantalla());

		}
		ReleaseMutex(hMutex);

		// Actualizamos el estado del teclado
		teclado.actualizar();

		estado = 0;

		if (teclado.pulso(Teclado::TECLA_NEUTRONES)){
			//Disparo de mina
			estado += 256;
			teclado.soltarTecla(Teclado::TECLA_NEUTRONES);

		}
		if (teclado.pulso(Teclado::TECLA_MINA)){
			//Disparo de mina
			estado += 128;
			teclado.soltarTecla(Teclado::TECLA_MINA);

			if(this->jugadorPartida->tieneBonus(MINA)){
				this->sonido->reproducir(this->sonido->getSoundMina());
			}
		}
		if (teclado.pulso(Teclado::TECLA_MISIL)){
			//Disparo de Misil
			estado += 64;
			teclado.soltarTecla(Teclado::TECLA_MISIL);
			if(this->jugadorPartida->tieneBonus(MISIL)){
				this->sonido->reproducir(this->sonido->getSoundMisil());
			}
		}
		if (teclado.pulso(Teclado::TECLA_BOMBA)){ 
			//Dispara Bonus bomba
			estado +=32;
			teclado.soltarTecla(Teclado::TECLA_BOMBA);
			if(this->jugadorPartida->tieneBonus(BOMBA)){
				this->sonido->reproducir(this->sonido->getSoundBomba());
			}
		}
		if(teclado.pulso(Teclado::TECLA_SUBIR)) {
			//Acelerar
			//sonido->reproducir(sonido->getSoundSubir());
			estado +=16;
		}else{
			//Frena
			estado +=8;
		}
		if(teclado.pulso(Teclado::TECLA_IZQUIERDA)) {
			//Dobla a la izquierda
			estado +=4;
		}
		if(teclado.pulso(Teclado::TECLA_DERECHA)) {
			//Dobla a la derecha
			estado +=2;
		}
		if (teclado.pulso(Teclado::TECLA_DISPARAR))
		{
			//Dispara
			estado +=1;
			teclado.soltarTecla(Teclado::TECLA_DISPARAR);
			if(this->jugadorPartida->tieneBonus(LASER)){
				this->sonido->reproducir(this->sonido->getSoundLaser());
			}else{
				this->sonido->reproducir(this->sonido->getSoundDisparar());
			}
		}


		int enviado = this->cliente->enviarEntero(estado);
		if(enviado == -1){
			terminar=true;
		}


		//Actualizo el tiempo en SDL
		if (1000/FPS >( SDL_GetTicks() - tiempoTranscurrido))
			SDL_Delay(1000/FPS -( SDL_GetTicks() - tiempoTranscurrido)); 

		// Control de Eventos de salida ESC y X
		while(SDL_PollEvent(&evento)) {

			if(evento.type == SDL_KEYDOWN) {
				if(evento.key.keysym.sym == SDLK_ESCAPE) {
					terminar = true;
					//cuando salgo, apreto el boton de salir, o escape. Paro el sonido
					this->sonido->pararAmbiente();
				}
			}
			if (evento.type == SDL_MOUSEBUTTONDOWN && evento.button.button == SDL_BUTTON_LEFT){
				if (botonSalir->fuiClickeado(evento.button.x,evento.button.y)){
					terminar = true;
					//cuando salgo, apreto el boton de salir, o escape. Paro el sonido
					this->sonido->pararAmbiente();
				}
			}
			if(evento.type == SDL_QUIT){
				terminar = true;
				//cuando salgo, apreto el boton de salir, o escape. Paro el sonido
				this->sonido->pararAmbiente();

			}
		}

		ReleaseMutex(hMutex);

		dwWaitResult = WaitForSingleObject(hMutex, INFINITE); 

		if (dwWaitResult == WAIT_OBJECT_0){

			if(this->jugadorPartida->getEstadoJugadorEnJuego() == GAME_OVER){  
				cout << "OH MY GOD, I LOOSE" << endl;
				//SDL_Surface* gameOverFondo = SDL_LoadBMP("gameOver.bmp");
				//SDL_BlitSurface(gameOverFondo,NULL,this->tablero->getPantalla(),NULL);
				terminar = true;
			}
			if(this->jugadorPartida->getEstadoJugadorEnJuego() == WIN){
				cout << "I WIN!!" << endl;
				//SDL_Surface* win = SDL_LoadBMP("youWin.bmp");
				//SDL_BlitSurface(win,NULL,this->tablero->getPantalla(),NULL);
				terminar = true;
			}

		}
		ReleaseMutex(hMutex);

	}
	this->setResultadoPartida(this->jugadorPartida->getEstadoJugadorEnJuego());
	this->cliente->enviarEntero(999);
	this->cliente->cerrarConexion();
}

int PartidaCliente::actualizarNave(char* mensajeServidor, int punteroBuffer){

	int puntero = punteroBuffer;

	double posX = *(double*)mensajeServidor;
	this->tablero->getNave()->setPosicionX(posX);
	puntero+=sizeof(double);

	double posY = *(double*)(mensajeServidor+puntero);
	this->tablero->getNave()->setPosicionY(posY);
	puntero+=sizeof(double);

	double rotacion = *(double*)(mensajeServidor+puntero);
	this->tablero->getNave()->setRotacionDeLaImagen(rotacion);
	puntero+=sizeof(double);

	int numeroDeFrames = *(int*)(mensajeServidor+puntero);
	this->tablero->getNave()->setNumeroDeFrame(numeroDeFrames);
	puntero+=sizeof(int);

	int cantidadEnergia = *(int*)(mensajeServidor+puntero);
	this->tablero->getNave()->getEnergia()->setCantidad(cantidadEnergia);
	puntero+=sizeof(int);

	bool estabaEnReparacion = this->tablero->getNave()->getEnReparacion();
	bool enReparacion = *(bool*)(mensajeServidor+puntero);
	if (!estabaEnReparacion && enReparacion){
			this->sonido->reproducir(this->sonido->getSoundExplosion());
			Animacion* animacion = new Animacion(this->tablero->getNave()->getPosicionX()-(this->tablero->getNave()->getAnchoDeLaImagen()/2),this->tablero->getNave()->getPosicionY()-(this->tablero->getNave()->getAnchoDeLaImagen()/2),
				"explosionBomba.bmp",this->tablero->getNave()->getAnchoDeLaImagen()*2,this->tablero->getNave()->getAltoDeLaImagen()*2,16);
			this->animaciones->push_back(animacion);
	
	}
	this->tablero->getNave()->setEnReparacion(enReparacion);
	puntero+=sizeof(bool);

	bool invisible = *(bool*)(mensajeServidor+puntero);
	if(this->tablero->getJugadorUno()->getNave()->esInvisible() && !invisible){
		this->tablero->getJugadorUno()->buscarBonus(INVISIBILIDAD);
	}
	this->tablero->getNave()->setInvisible(invisible);
	puntero+=sizeof(bool);

	return puntero;
}

int PartidaCliente::actualizarNaveOtroCliente(char* mensajeServidor, int punteroBuffer){

	int posIncialDatos = punteroBuffer;

	//NAVE 2
	double posX = *(double*)(mensajeServidor+posIncialDatos);
	this->tablero->getNaveOtroCliente()->setPosicionX(posX);
	posIncialDatos+=sizeof(double);

	double posY = *(double*)(mensajeServidor+posIncialDatos);
	this->tablero->getNaveOtroCliente()->setPosicionY(posY);
	posIncialDatos+=sizeof(double);

	double rotacion = *(double*)(mensajeServidor+posIncialDatos);
	this->tablero->getNaveOtroCliente()->setRotacionDeLaImagen(rotacion);
	posIncialDatos+=sizeof(double);

	int numeroDeFrames = *(int*)(mensajeServidor+posIncialDatos);
	this->tablero->getNaveOtroCliente()->setNumeroDeFrame(numeroDeFrames);
	posIncialDatos+=sizeof(int);

	int cantidadEnergia = *(int*)(mensajeServidor+posIncialDatos);
	this->tablero->getNaveOtroCliente()->getEnergia()->setCantidad(cantidadEnergia);
	posIncialDatos+=sizeof(int);

	bool estabaEnReparacion = this->tablero->getNaveOtroCliente()->getEnReparacion();
	bool enReparacion = *(bool*)(mensajeServidor+posIncialDatos);
	if (!estabaEnReparacion && enReparacion){
			this->sonido->reproducir(this->sonido->getSoundExplosion());
			Animacion* animacion = new Animacion(this->tablero->getNaveOtroCliente()->getPosicionX()-(this->tablero->getNaveOtroCliente()->getAnchoDeLaImagen()/2),this->tablero->getNaveOtroCliente()->getPosicionY()-(this->tablero->getNaveOtroCliente()->getAnchoDeLaImagen()/2),
				"explosionBomba.bmp",this->tablero->getNaveOtroCliente()->getAnchoDeLaImagen()*2,this->tablero->getNaveOtroCliente()->getAltoDeLaImagen()*2,16);
			this->animaciones->push_back(animacion);
	
	}
	this->tablero->getNaveOtroCliente()->setEnReparacion(enReparacion);
	posIncialDatos+=sizeof(bool);

	bool invisible = *(bool*)(mensajeServidor+posIncialDatos);
	if(this->tablero->getJugadorDos()->getNave()->esInvisible() && !invisible){
		this->tablero->getJugadorDos()->buscarBonus(INVISIBILIDAD);
	}
	this->tablero->getNaveOtroCliente()->setInvisible(invisible);
	posIncialDatos+=sizeof(bool);

	return posIncialDatos;
}

int PartidaCliente::actualizarAsteroides(char* mensajeServidor, int punteroBuffer){

	vector<Asteroide*>* nuevosAsteroides = new vector<Asteroide*>;
	//Me muevo en el buffer sobre los datos para llegarn a la cantidad de asteroides.
	int posIncialCantAsteroides = punteroBuffer;
	int cantidadAsteroides = *(int*)(mensajeServidor+posIncialCantAsteroides);

	int posicionDatos = posIncialCantAsteroides+sizeof(int);
	int tamanioBufferAsteroides = 0;

	for (int i = 0;i < cantidadAsteroides; i++){

		int CANT = this->tablero->getAsteroides()->size();
		double posicionX = *(double*)(mensajeServidor + posicionDatos);
		this->tablero->getAsteroides()->at(i)->setPosicionX(posicionX);
		posicionDatos += sizeof(double);

		double posicionY = *(double*)(mensajeServidor+posicionDatos);
		this->tablero->getAsteroides()->at(i)->setPosicionY(posicionY);
		posicionDatos += sizeof(double);

		//int nuevoTamanioAsteroide = *(int*)(mensajeServidor+posicionDatos);
		//int tamanioAnterior = this->tablero->getAsteroides()->at(i)->getTamanioAsteroide();
		//this->tablero->getAsteroides()->at(i)->setTamanioAsteroide(nuevoTamanioAsteroide);
		//if (nuevoTamanioAsteroide < tamanioAnterior && nuevoTamanioAsteroide != 0){
		//	int diferencia = tamanioAnterior - nuevoTamanioAsteroide;

		//	for (int j = 0; j < diferencia ; j++){
		//		nuevosAsteroides->push_back(this->tablero->getAsteroides()->at(i)->dividirseEnDos());
		//	}
		//}

		int nuevoTamanioAsteroide = *(int*)(mensajeServidor+posicionDatos);
		int tamanioAnterior = this->tablero->getAsteroides()->at(i)->getTamanioAsteroide();
		if (nuevoTamanioAsteroide < tamanioAnterior){
			int diferencia = tamanioAnterior - nuevoTamanioAsteroide;
			for (int j = 0; j < diferencia ; j++){
				this->tablero->getAsteroides()->at(i)->setTamanioAsteroide(this->tablero->getAsteroides()->at(i)->getTamanioAsteroide()-1);
				if (this->tablero->getAsteroides()->at(i)->getTamanioAsteroide() != 0){
					nuevosAsteroides->push_back(this->tablero->getAsteroides()->at(i)->dividirseEnDos());
				}
			}
		}else{
			this->tablero->getAsteroides()->at(i)->setTamanioAsteroide(nuevoTamanioAsteroide);
		}

		posicionDatos += sizeof(int);

	}
	//Nuevos asteroides irian aca 
	for (int i = 0;i < nuevosAsteroides->size();i++){
		this->tablero->getAsteroides()->push_back(nuevosAsteroides->at(i));
	}

	delete nuevosAsteroides;
	bool quedanAsteroides = *(bool*)(mensajeServidor+posicionDatos);
	posicionDatos += sizeof(bool);
	if(!quedanAsteroides){
		for (int i = 0;i < this->tablero->getBackupAsteroides()->size();i++){
			Asteroide* asteroideBackUp = this->tablero->getBackupAsteroides()->at(i);
			Asteroide* asteroide = new Asteroide(asteroideBackUp->getDireccionActual(),asteroideBackUp->getVelocidad()*15, 
			asteroideBackUp->getTipoDeAsteroide(), asteroideBackUp->getPosicionX(), asteroideBackUp->getPosicionY(),
			asteroideBackUp->getPathDeLaImagen(), asteroideBackUp->getAnchoDeLaImagen(), asteroideBackUp->getAltoDeLaImagen(), 
			asteroideBackUp->getRotacionDeLaImagen());
			this->tablero->getAsteroides()->push_back(asteroide);
		}
	}
	

	for(int i=0; i < this->tablero->getAsteroides()->size();i++){
		if((this->tablero->getAsteroides()->at(i)->getTamanioAsteroide()) == 0){

			int alto = this->tablero->getAsteroides()->at(i)->getAltoDeLaImagen();
			int ancho = this->tablero->getAsteroides()->at(i)->getAnchoDeLaImagen();
			if (alto > ancho )
			      ancho =alto;
			this->sonido->reproducir(this->sonido->getSoundChoque());
			Animacion* animacion = new Animacion(this->tablero->getAsteroides()->at(i)->getPosicionX(),this->tablero->getAsteroides()->at(i)->getPosicionY(),
			      "explosionNave.bmp",ancho*2,ancho*2,5);
			this->animaciones->push_back(animacion);
			//hay q borrarla en el cliente
			Asteroide* asteroideAEliminar =  this->tablero->getAsteroides()->at(i);
			this->tablero->getAsteroides()->erase(this->tablero->getAsteroides()->begin()+i);
			delete asteroideAEliminar;
		}
	}
	return posicionDatos;
}

int PartidaCliente::actualizarArmas(char* mensajeServidor,int punteroEnBuffer){

	//ARMAS CLIENTE UNO
	int posArmasCli1 = punteroEnBuffer;
	int cantidadArmasCli1 = *(int*)(mensajeServidor+posArmasCli1);
	posArmasCli1 += sizeof(int);

	for (int i = 0;i < cantidadArmasCli1; i++){

		double posicionX = *(double*)(mensajeServidor+posArmasCli1);
		this->tablero->getArmas()->at(i)->setPosicionX(posicionX);
		posArmasCli1 += sizeof(double);

		double posicionY = *(double*)(mensajeServidor+posArmasCli1);
		this->tablero->getArmas()->at(i)->setPosicionY(posicionY);
		posArmasCli1 += sizeof(double);

		int duracion = *(int*)(mensajeServidor+posArmasCli1);
		this->tablero->getArmas()->at(i)->setDuracion(duracion);
		posArmasCli1 += sizeof(int);

		char estado = *(char*)(mensajeServidor+posArmasCli1);
		this->tablero->getArmas()->at(i)->setEstado(estado);
		posArmasCli1 += sizeof(char);

		int numeroDeFrame = *(int*)(mensajeServidor+posArmasCli1);
		this->tablero->getArmas()->at(i)->setNumeroDeFrame(numeroDeFrame);
		posArmasCli1 += sizeof(int);

	}

	int cantArmasNuevas1 =  *(int*)(mensajeServidor + posArmasCli1);
	posArmasCli1 += sizeof(int);

	if (cantArmasNuevas1 > 0){

		for (int i = 0; i < cantArmasNuevas1; i ++){

			char tipo = *(char*)(mensajeServidor+posArmasCli1);
			posArmasCli1 += sizeof(char);
			Arma* arma;

			switch(tipo){
						case 'A': arma = this->tablero->getNave()->disparar(); break;
						case 'B': arma = this->tablero->getNave()->dispararBomba(); break;
						case 'M': arma = this->tablero->getNave()->dispararMisil(); break;
						case 'I': arma = this->tablero->getNave()->dispararMina();  break; 
						case 'L': arma = this->tablero->getNave()->dispararLaser(); break; 
			}

			double posicionX = *(double*)(mensajeServidor+posArmasCli1);
			arma->setPosicionX(posicionX);
			posArmasCli1 += sizeof(double);

			double posicionY = *(double*)(mensajeServidor+posArmasCli1);
			arma->setPosicionY(posicionY);
			posArmasCli1 += sizeof(double);

			int duracion = *(int*)(mensajeServidor+posArmasCli1);
			arma->setDuracion(duracion);
			posArmasCli1 += sizeof(int);

			char estado = *(char*)(mensajeServidor+posArmasCli1);
			arma->setEstado(estado);
			posArmasCli1 += sizeof(char);

			this->tablero->getArmas()->push_back(arma);

		}
	}

	//BALAS CLIENTE DOS
	int posArmasCli2 = posArmasCli1;
	int cantidadArmasCli2 = *(int*)(mensajeServidor+posArmasCli2);
	posArmasCli2 += sizeof(int);

	for (int i = 0;i < cantidadArmasCli2; i++){

		double posicionX = *(double*)(mensajeServidor+posArmasCli2);
		this->tablero->getArmasOtroCliente()->at(i)->setPosicionX(posicionX);
		posArmasCli2 += sizeof(double);

		double posicionY = *(double*)(mensajeServidor+posArmasCli2);
		this->tablero->getArmasOtroCliente()->at(i)->setPosicionY(posicionY);
		posArmasCli2 += sizeof(double);

		int duracion = *(int*)(mensajeServidor+posArmasCli2);
		this->tablero->getArmasOtroCliente()->at(i)->setDuracion(duracion);
		posArmasCli2 += sizeof(int);

		char estado = *(char*)(mensajeServidor+posArmasCli2);
		this->tablero->getArmasOtroCliente()->at(i)->setEstado(estado);
		posArmasCli2 += sizeof(char);

		int numeroDeFrame = *(int*)(mensajeServidor+posArmasCli2);
		this->tablero->getArmasOtroCliente()->at(i)->setNumeroDeFrame(numeroDeFrame);
		posArmasCli2 += sizeof(int);

	}

	int cantArmasNuevas2 =  *(int*)(mensajeServidor + posArmasCli2);
	posArmasCli2 += sizeof(int);

	if (cantArmasNuevas2 > 0){

		for (int i = 0; i < cantArmasNuevas2; i++) {    

			char tipo = *(char*)(mensajeServidor+posArmasCli2);
			posArmasCli2 += sizeof(char);
			Arma* arma;

			switch(tipo){
						case 'A': arma = this->tablero->getNaveOtroCliente()->disparar(); break;
						case 'B': arma = this->tablero->getNaveOtroCliente()->dispararBomba();  break;
						case 'M': arma = this->tablero->getNaveOtroCliente()->dispararMisil();  break;
						case 'I': arma = this->tablero->getNaveOtroCliente()->dispararMina();   break; 
						case 'L': arma = this->tablero->getNaveOtroCliente()->dispararLaser();  break; 
			}

			double posicionX = *(double*)(mensajeServidor+posArmasCli2);
			arma->setPosicionX(posicionX);
			posArmasCli2 += sizeof(double);

			double posicionY = *(double*)(mensajeServidor+posArmasCli2);
			arma->setPosicionY(posicionY);
			posArmasCli2 += sizeof(double);

			int duracion = *(int*)(mensajeServidor+posArmasCli2);
			arma->setDuracion(duracion);
			posArmasCli2 += sizeof(int);

			char estado = *(char*)(mensajeServidor+posArmasCli2);
			arma->setEstado(estado);
			posArmasCli2 += sizeof(char);

			this->tablero->getArmasOtroCliente()->push_back(arma);
		}

	}

	//Eliminamos del tablero las balas que tienen duracion 0.
	for(int i=0; i < this->tablero->getArmasOtroCliente()->size();i++){
		if((this->tablero->getArmasOtroCliente()->at(i)->getDuracion()) <= 0){
				if (this->tablero->getArmasOtroCliente()->at(i)->getTipo() == 'B' && this->tablero->getArmasOtroCliente()->at(i)->getEstado() == 'F'){
					  this->sonido->reproducir(sonido->getSoundBomba());
					  this->animacionesBonus(BOMBA,this->tablero->getArmasOtroCliente()->at(i));                                 
				}
							//hay q borrarla en el cliente
			Arma* armaAEliminar =  this->tablero->getArmasOtroCliente()->at(i);
			this->tablero->getArmasOtroCliente()->erase(this->tablero->getArmasOtroCliente()->begin()+i);
			delete armaAEliminar;
		}
	}
	for(int i=0; i < this->tablero->getArmas()->size();i++){
		if((this->tablero->getArmas()->at(i)->getDuracion()) <= 0){

				if (this->tablero->getArmas()->at(i)->getTipo() == 'B' && this->tablero->getArmas()->at(i)->getEstado() == 'F'){
					  this->sonido->reproducir(sonido->getSoundBomba());
					  this->animacionesBonus(BOMBA,this->tablero->getArmas()->at(i));                                 
				}
			//hay q borrarla en el cliente
			Arma* armaAEliminar =  this->tablero->getArmas()->at(i);
			this->tablero->getArmas()->erase(this->tablero->getArmas()->begin()+i);
			delete armaAEliminar;
		}
	}

	return posArmasCli2;

}


int PartidaCliente::actualizarBonus(char* mensajeServidor,int punteroEnBuffer){

	int posBonus = punteroEnBuffer;
	int cantidadBonus = *(int*)(mensajeServidor+posBonus);
	posBonus += sizeof(int);

	for (int i = 0;i < cantidadBonus; i++){

		double posicionX = *(double*)(mensajeServidor+posBonus);
		this->tablero->getBonus()->at(i)->setPosicionX(posicionX);
		posBonus += sizeof(double);

		double posicionY = *(double*)(mensajeServidor+posBonus);
		this->tablero->getBonus()->at(i)->setPosicionY(posicionY);
		posBonus += sizeof(double);

		int duracion = *(int*)(mensajeServidor+posBonus);
		this->tablero->getBonus()->at(i)->setDuracion(duracion);
		posBonus += sizeof(int);

		int numeroFrame = *(int*)(mensajeServidor+posBonus);
		this->tablero->getBonus()->at(i)->setNumeroDeFrame(numeroFrame);
		posBonus += sizeof(int);
	}

	int cantBonusNuevos =  *(int*)(mensajeServidor + posBonus);
	posBonus += sizeof(int);

	if (cantBonusNuevos > 0){

		for (int i = 0; i < cantBonusNuevos; i ++){

			double posicionX = *(double*)(mensajeServidor+posBonus);
			posBonus += sizeof(double);

			double posicionY = *(double*)(mensajeServidor+posBonus);
			posBonus += sizeof(double);

			int duracion = *(int*)(mensajeServidor+posBonus);
			posBonus += sizeof(int);

			int numeroFrame = *(int*)(mensajeServidor+posBonus);
			posBonus += sizeof(int);

			GeneradorBonus* bonus = new GeneradorBonus(posicionX,posicionY,"BonusSprite.bmp",30,30,8);
			bonus->setDuracion(duracion);
			bonus->setNumeroDeFrame(numeroFrame);
			this->tablero->getBonus()->push_back(bonus);
		}
	}

	for(int i=0; i < this->tablero->getBonus()->size();i++){
		if((this->tablero->getBonus()->at(i)->getDuracion()) <= 0){
			//hay q borrarla en el cliente
			GeneradorBonus* bonusAEliminar =  this->tablero->getBonus()->at(i);
			this->tablero->getBonus()->erase(this->tablero->getBonus()->begin()+i);
			delete bonusAEliminar;
		}
	}

	return posBonus;
}

int PartidaCliente::actualizarDefensas(char* mensajeServidor,int punteroEnBuffer, Nave* nave){

	// escudo
	double posicionXEscudo = *(double*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(double);

	double posicionYEscudo = *(double*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(double);

	char estadoEscudo = *(char*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(char);

	int vidaEscudo = *(int*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(int);

	int duracionEscudo = *(int*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(int);

	if (nave->getEscudo() != NULL){
		if (estadoEscudo == 'D' || vidaEscudo <= 0 || estadoEscudo == 'X') 
			nave->eliminarEscudo();
		else {
			nave->getEscudo()->getEnergia()->setCantidad(vidaEscudo);
			nave->getEscudo()->setPosicionX(posicionXEscudo);
			nave->getEscudo()->setPosicionY(posicionYEscudo);
			nave->getEscudo()->getEnergia()->posicionarse(nave->getEscudo()->getAltoDeLaImagen(),nave->getEscudo()->getAnchoDeLaImagen(),
				posicionXEscudo,posicionYEscudo + 15);
		}
	} else {
		if (estadoEscudo == 'A') {
			nave->agregarEscudo();
			nave->getEscudo()->setPosicionX(posicionXEscudo);
			nave->getEscudo()->setPosicionY(posicionYEscudo);
		}
	}

	// SuperEscudo
	double posicionXSuperEscudo = *(double*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(double);

	double posicionYSuperEscudo = *(double*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(double);

	char estadoSuperEscudo = *(char*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(char);

	int duracionSuperEscudo = *(int*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer += sizeof(int);

	if (nave->getSuperEscudo() == NULL && estadoSuperEscudo == 'A'){
		nave->agregarSuperEscudo();
		nave->getSuperEscudo()->setPosicionX(posicionXSuperEscudo);
		nave->getSuperEscudo()->setPosicionY(posicionYSuperEscudo);
	}else{
		if (estadoSuperEscudo == 'A'){
			nave->getSuperEscudo()->setPosicionX(posicionXSuperEscudo);
			nave->getSuperEscudo()->setPosicionY(posicionYSuperEscudo);
		}else if (estadoSuperEscudo == 'X'){
			nave->eliminarSuperEscudo();
		}
	}

	return punteroEnBuffer;
}

int PartidaCliente::actualizarJugadores(char* mensajeServidor,int punteroEnBuffer){

	//Me muevo en el buffer sobre las bases
	int cantidadEnergiaUno = *(int*)(mensajeServidor+punteroEnBuffer);
	this->tablero->getJugadorUno()->getBase()->getEnergia()->setCantidad(cantidadEnergiaUno);
	punteroEnBuffer+=sizeof(int);

	int cantidadBonusUsados1 = *(int*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer+=sizeof(int);
	for (int i = 0; i < cantidadBonusUsados1; i++){
		bonus_disponibles bonusUno = *(bonus_disponibles*)(mensajeServidor+punteroEnBuffer);
		punteroEnBuffer+=sizeof(bonus_disponibles);
		if( bonusUno == NEUTRONES && !this->tablero->getNave()->getEnReparacion()){
			this->animacionesBonus(bonusUno,NULL);
		}
		this->tablero->getJugadorUno()->buscarBonus(bonusUno);
	}

	GeneradorBonus* generadorBonus = new GeneradorBonus(0,0,"BonusSprite.bmp",30,30,8);

	int cantidadBonusNuevos1 = *(int*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer+=sizeof(int);

	for (int i = 0; i < cantidadBonusNuevos1; i++){
		bonus_disponibles bonusUno = *(bonus_disponibles*)(mensajeServidor+punteroEnBuffer);
		punteroEnBuffer+=sizeof(bonus_disponibles);
		Bonus* bonus = generadorBonus->getInstanciaBonus(bonusUno);
		this->tablero->getJugadorUno()->agregarBonus(bonus);
	}

	estados_juego estadoPartidaUno = *(estados_juego*)(mensajeServidor+punteroEnBuffer);
	this->tablero->getJugadorUno()->setEstadoJugadorEnJuego(estadoPartidaUno);
	punteroEnBuffer+=sizeof(estados_juego);

	int cantidadVidasUno = *(int*)(mensajeServidor+punteroEnBuffer);
	this->tablero->getJugadorUno()->setCantidadDeVidas(cantidadVidasUno);
	punteroEnBuffer+=sizeof(int);

	int cantidadEnergiaDos = *(int*)(mensajeServidor+punteroEnBuffer);
	this->tablero->getJugadorDos()->getBase()->getEnergia()->setCantidad(cantidadEnergiaDos);
	punteroEnBuffer+=sizeof(int);

	int cantidadBonusUsados2 = *(int*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer+=sizeof(int);
	for (int i = 0; i < cantidadBonusUsados2; i++){
		bonus_disponibles bonusDos = *(bonus_disponibles*)(mensajeServidor+punteroEnBuffer);
		punteroEnBuffer+=sizeof(bonus_disponibles);
		if( bonusDos == NEUTRONES && !this->tablero->getNaveOtroCliente()->getEnReparacion()){
			this->animacionesBonus(bonusDos,NULL);
		}
		this->tablero->getJugadorDos()->buscarBonus(bonusDos);
	}

	int cantidadBonusNuevos2 = *(int*)(mensajeServidor+punteroEnBuffer);
	punteroEnBuffer+=sizeof(int);
	for (int i = 0; i < cantidadBonusNuevos2; i++){
		bonus_disponibles bonusDos = *(bonus_disponibles*)(mensajeServidor+punteroEnBuffer);
		punteroEnBuffer+=sizeof(bonus_disponibles);
		Bonus* bonus = generadorBonus->getInstanciaBonus(bonusDos);
		this->tablero->getJugadorDos()->agregarBonus(bonus);
	}

	estados_juego estadoPartidaDos = *(estados_juego*)(mensajeServidor+punteroEnBuffer);
	this->tablero->getJugadorDos()->setEstadoJugadorEnJuego(estadoPartidaDos);
	punteroEnBuffer+=sizeof(estados_juego);

	int cantidadVidasDos = *(int*)(mensajeServidor+punteroEnBuffer);
	this->tablero->getJugadorDos()->setCantidadDeVidas(cantidadVidasDos);
	punteroEnBuffer+=sizeof(int);

	delete generadorBonus;

	return punteroEnBuffer;

}

void PartidaCliente::animacionesBonus(bonus_disponibles bonusUsado, Pintable* pintable){

	int posX = 0;
	int posY = 0;
	Animacion* animacion = NULL;
	if (pintable != NULL){
		posX = pintable->getPosicionX();
		posY = pintable->getPosicionY();
	}

	switch(bonusUsado){
						case NEUTRONES: animacion = new Animacion(0,0,"EfectoBombaNeutrones.bmp",this->tablero->getAncho(),this->tablero->getAlto(),5);
													this->sonido->reproducir(sonido->getSoundNeutrones());
							break;
						case BOMBA: 
							posX = posX - 100 + (pintable->getAltoDeLaImagen() /2 );
							posY = posY - 100 + (pintable->getAltoDeLaImagen() /2 );
							animacion = new Animacion(posX,posY ,"explosionBomba.bmp",200,200,16);
							break;
						case MINA: animacion = new Animacion(posX - 50,posY -50,"explosionBomba.bmp",100,100,16);
							break;
	}
	if (animacion != NULL){
		this->animaciones->push_back(animacion);
	}

}

bool PartidaCliente::recibirEstadoEscenario(){

	DWORD ThreadID;
	RecibirEstadoEscenario_Data * data = (RecibirEstadoEscenario_Data *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RecibirEstadoEscenario_Data));
	data->partidaCliente = this;
	CreateThread(NULL, 0, RecibirEstadoEscenario_StaticThreadStart, data, 0, &ThreadID);

	return true;
}


bool PartidaCliente::recibirEstadoEscenarioThread(){

	//Mientras alla una conexion activa 
	while (this->cliente->socketClient != INVALID_SOCKET){

		//recibo mensaje del servidor con el tamanio del mensaje a recibir.
		int tamanioMensajeServidor = this->cliente->recibirEntero();

		if (tamanioMensajeServidor > 0){

			char* mensajeServidor = new char[tamanioMensajeServidor];

			int tamanioMensajeRecibido = this->cliente->recibir(mensajeServidor,tamanioMensajeServidor);

			//Verifico que el  mensaje que recibi del servidor sea correcto 
			if (tamanioMensajeRecibido == tamanioMensajeServidor){

				HANDLE hMutex = CreateMutex(NULL, FALSE, TEXT("datosMutex"));

				DWORD dwWaitResult = WaitForSingleObject(hMutex, INFINITE); 

				if (dwWaitResult == WAIT_OBJECT_0){

					int punteroEnBuffer = 0;
					//NAVE 1
					punteroEnBuffer = actualizarNave(mensajeServidor,punteroEnBuffer);

					//NAVE 2
					punteroEnBuffer = actualizarNaveOtroCliente(mensajeServidor,punteroEnBuffer);

					//ASTEROIDES
					//punteroEnBuffer = actualizarAsteroides(mensajeServidor,punteroEnBuffer);
					punteroEnBuffer = actualizarAsteroidesBis(mensajeServidor,punteroEnBuffer);

					//DEFENSAS
					punteroEnBuffer = actualizarDefensas(mensajeServidor,punteroEnBuffer, this->tablero->getNave());
					punteroEnBuffer = actualizarDefensas(mensajeServidor,punteroEnBuffer, this->tablero->getNaveOtroCliente());

					//ARMAS CLIENTES
					punteroEnBuffer = actualizarArmas(mensajeServidor,punteroEnBuffer);

					//Estado de los jugadores
					punteroEnBuffer = actualizarJugadores(mensajeServidor,punteroEnBuffer);

					//Bonus
					punteroEnBuffer = actualizarBonus(mensajeServidor,punteroEnBuffer);

				}
				ReleaseMutex(hMutex);

			}
			delete [] mensajeServidor;
		}
	}

	return 0;
}

void PartidaCliente::pintarBase(Jugador* jugador){
	jugador->getBase()->framesCircular();
	jugador->getBase()->pintarImagen(this->tablero->getPantalla());
	jugador->getBase()->mostrarNombre(this->tablero->getPantalla());
	jugador->getBase()->getEnergia()->pintarImagen(this->tablero->getPantalla());
	if ( jugador->getCantidadDeVidas() > 0){
		for(unsigned int i = 0;i< jugador->getCantidadDeVidas();i++){
			Vida* vida = jugador->getBase()->getVidas()->at(i);
			vida->pintarImagen(this->tablero->getPantalla());
			vida->framesCircular();
		}
	}
}

int PartidaCliente::actualizarAsteroidesBis(char* mensajeServidor, int punteroBuffer){

	vector<Asteroide*>* nuevosAsteroides = new vector<Asteroide*>;
	//Me muevo en el buffer sobre los datos para llegarn a la cantidad de asteroides.
	int posIncialCantAsteroides = punteroBuffer;
	int cantidadAsteroides = *(int*)(mensajeServidor+posIncialCantAsteroides);
	int posicionDatos = posIncialCantAsteroides+sizeof(int);
	int tamanioBufferAsteroides = 0;

	for (int i = 0;i < cantidadAsteroides; i++){

		int CANT = this->tablero->getAsteroides()->size();
		if (cantidadAsteroides != CANT){ 
	   			cout<<"ERROR"<<endl;
		}

		double posicionX = *(double*)(mensajeServidor + posicionDatos);
		this->tablero->getAsteroides()->at(i)->setPosicionX(posicionX);
		posicionDatos += sizeof(double);

		double posicionY = *(double*)(mensajeServidor+posicionDatos);
		this->tablero->getAsteroides()->at(i)->setPosicionY(posicionY);
		posicionDatos += sizeof(double);

		//int nuevoTamanioAsteroide = *(int*)(mensajeServidor+posicionDatos);
		//int tamanioAnterior = this->tablero->getAsteroides()->at(i)->getTamanioAsteroide();
		//this->tablero->getAsteroides()->at(i)->setTamanioAsteroide(nuevoTamanioAsteroide);
		//if (nuevoTamanioAsteroide < tamanioAnterior && nuevoTamanioAsteroide != 0){
		//	int diferencia = tamanioAnterior - nuevoTamanioAsteroide;

		//	for (int j = 0; j < diferencia ; j++){
		//		nuevosAsteroides->push_back(this->tablero->getAsteroides()->at(i)->dividirseEnDos());
		//	}
		//}

		//int nuevoTamanioAsteroide = *(int*)(mensajeServidor+posicionDatos);
		//int tamanioAnterior = this->tablero->getAsteroides()->at(i)->getTamanioAsteroide();
		//if (nuevoTamanioAsteroide < tamanioAnterior){
		//	int diferencia = tamanioAnterior - nuevoTamanioAsteroide;
		//	for (int j = 0; j < diferencia ; j++){
		//		this->tablero->getAsteroides()->at(i)->setTamanioAsteroide(this->tablero->getAsteroides()->at(i)->getTamanioAsteroide()-1);
		//		if (this->tablero->getAsteroides()->at(i)->getTamanioAsteroide() >= 1){
		//			//nuevosAsteroides->push_back(this->tablero->getAsteroides()->at(i)->dividirseEnDos());
		//			this->tablero->getAsteroides()->at(i)->obtenerMitad();
		//		}
		//	}
		//}else{
		//	this->tablero->getAsteroides()->at(i)->setTamanioAsteroide(nuevoTamanioAsteroide);
		//}

		int nuevoTamanioAsteroide = *(int*)(mensajeServidor+posicionDatos);
		int tamanioAnterior = this->tablero->getAsteroides()->at(i)->getTamanioAsteroide();
		this->tablero->getAsteroides()->at(i)->setTamanioAsteroide(nuevoTamanioAsteroide);
		if (nuevoTamanioAsteroide < tamanioAnterior){
			int diferencia = tamanioAnterior - nuevoTamanioAsteroide;
			for (int j = 0; j < diferencia ; j++){
					this->tablero->getAsteroides()->at(i)->obtenerMitad();
			}
		}

		posicionDatos += sizeof(int);

	}

	int cantNuevos = *(int*)(mensajeServidor+posicionDatos);
	posicionDatos += sizeof(int);

	for (int i = 0 ; i < cantNuevos ; i++){

		double posicionX = *(double*)(mensajeServidor + posicionDatos);
		posicionDatos += sizeof(double);

		double posicionY = *(double*)(mensajeServidor+posicionDatos);
		posicionDatos += sizeof(double);

		int tamanioAsteroide = *(int*)(mensajeServidor+posicionDatos);
		posicionDatos += sizeof(int);

		double velocidad = *(double*)(mensajeServidor+posicionDatos);
		posicionDatos += sizeof(double);

		double direccion = *(double*)(mensajeServidor+posicionDatos);
		posicionDatos += sizeof(double);

		int ancho = *(int*)(mensajeServidor+posicionDatos);
		posicionDatos += sizeof(int);

		int alto = *(int*)(mensajeServidor+posicionDatos);
		posicionDatos += sizeof(int);

		double rotacion = *(double*)(mensajeServidor+posicionDatos);
		posicionDatos += sizeof(double);

		int posicionTipo = *(int*)(mensajeServidor+posicionDatos);
		posicionDatos += sizeof(int);

		string tipo = this->tablero->getTiposAsteroides()->at(posicionTipo).nombre;
		string pathDeLaImagen = this->tablero->getTiposAsteroides()->at(posicionTipo).pathDeLaImagen;

		Asteroide* nuevoAsteroide = new Asteroide(direccion,velocidad,tipo,posicionX,posicionY,pathDeLaImagen,ancho,alto,rotacion);
		nuevoAsteroide->setTamanioAsteroide(tamanioAsteroide);

		nuevosAsteroides->push_back(nuevoAsteroide);

	}
	for (int i = 0; i < nuevosAsteroides->size(); i++){

		this->tablero->getAsteroides()->push_back(nuevosAsteroides->at(i));
	}

	delete nuevosAsteroides;

	bool quedanAsteroides = *(bool*)(mensajeServidor+posicionDatos);
	posicionDatos += sizeof(bool);
	if(!quedanAsteroides){
		for (int i = 0;i < this->tablero->getBackupAsteroides()->size();i++){
			Asteroide* asteroideBackUp = this->tablero->getBackupAsteroides()->at(i);
			Asteroide* asteroide = new Asteroide(asteroideBackUp->getDireccionActual(),asteroideBackUp->getVelocidad()*15, 
				asteroideBackUp->getTipoDeAsteroide(), asteroideBackUp->getPosicionX(), asteroideBackUp->getPosicionY(),
				asteroideBackUp->getPathDeLaImagen(), asteroideBackUp->getAnchoDeLaImagen(), asteroideBackUp->getAltoDeLaImagen(), 
				asteroideBackUp->getRotacionDeLaImagen());
			this->tablero->getAsteroides()->push_back(asteroide);
		}
	}


	for(int i=0; i < this->tablero->getAsteroides()->size();i++){
		if((this->tablero->getAsteroides()->at(i)->getTamanioAsteroide()) == 0){

			int alto = this->tablero->getAsteroides()->at(i)->getAltoDeLaImagen();
			int ancho = this->tablero->getAsteroides()->at(i)->getAnchoDeLaImagen();
			if (alto > ancho )
				ancho =alto;
			this->sonido->reproducir(this->sonido->getSoundChoque());
			Animacion* animacion = new Animacion(this->tablero->getAsteroides()->at(i)->getPosicionX(),this->tablero->getAsteroides()->at(i)->getPosicionY(),
				"explosionNave.bmp",ancho*2,ancho*2,5);
			this->animaciones->push_back(animacion);
			//hay q borrarla en el cliente
			Asteroide* asteroideAEliminar =  this->tablero->getAsteroides()->at(i);
			this->tablero->getAsteroides()->erase(this->tablero->getAsteroides()->begin()+i);
			delete asteroideAEliminar;
		}
	}
	return posicionDatos;
}

PartidaCliente::~PartidaCliente(void)
{
	if( this->cliente != NULL){

		delete this->cliente;
	}

	if( this->tablero != NULL){
		delete this->tablero;
	}
	delete this->sonido;

	for(int i=0; i < this->animaciones->size();i++){

		delete this->animaciones->at(i);
	}
	delete this->animaciones;

}